In some business computer systems, users often create calculation tasks and set a dependency relationship among the calculation tasks. For example, a particular task can only be run when the execution of all of its dependent tasks are completed. Additionally, users normally set different tasks to different calculation policies. For example, one cycle task is run every day, while another cycle task is run every week, while yet another cycle task is run on a monthly basis, and so on and so forth.
Such business computer systems can experience problems. For example, the business system often returns error messages during the execution of these calculation tasks. A reason for the errors is that a task cannot be executed because its dependent tasks have not yet been executed. Such business systems currently do not consider dependency relationships among the plurality of tasks. Moreover, when all of the tasks are loaded into a task scheduler, initiation of some of the tasks occurs even though their dependent tasks are not done executing. This results in an error, and further results in perhaps additional attempts (maybe resulting in additional errors) to run the failed tasks at a later time. Simply put, the root cause of the problem is that the business system doesn't know when all dependent tasks of the failed tasks are done. The current solution to this problem is simply to continuously run the failed tasks.
An additional problem arises when there are improper loop dependencies in the business system. FIG. 1 illustrates a simple improper loop dependency, wherein task A (110) is dependent on input from task B (120), task B (120) is dependent on input from task C (130), and task C (130) is dependent on input from task A (110). While the improper loop dependency in FIG. 1 is quite apparent upon simple inspection, in complex business systems, such loop dependencies can be much more complex (e.g., if there are over a thousand calculation tasks) and much more difficult to identify.